home *** CD-ROM | disk | FTP | other *** search
/ CD Ware Multimedia 1995 May / cd Ware (Juegos) Epimundo.iso / DOS / C / WLIB.ZIP / WOBJVEC.C < prev    next >
Encoding:
C/C++ Source or Header  |  1993-09-07  |  6.8 KB  |  325 lines
  1. #include "VecLocal.h"
  2. #pragma hdrstop
  3.  
  4. // copyright (c) 1992, 1993 by Paul Wheaton
  5.  
  6. //.parse
  7.  
  8. void ObjVec::ExtraAlloc(long Quan)
  9.   {
  10.     ByteVector::ExtraAlloc(Quan*BlockSize);
  11.   }
  12.  
  13. //.parse
  14.  
  15. void ObjVec::CopyFrom(void* Source, long Quan)
  16.   {
  17.     ByteVector::CopyFrom(Source,Quan*ObjSize);
  18.   }
  19.  
  20. //.parse
  21.  
  22. void ObjVec::AppendOneObj(void* X)
  23.   {
  24.     memcpy(Ref(Size()),X,ObjSize);
  25.   }
  26.  
  27. //.parse
  28.  
  29. ObjVec ObjVec::PrependOneObj(void* X) const
  30.   {
  31.     ObjVec V(ObjSize,X);
  32.     V+=*this;
  33.     return V;
  34.   }
  35.  
  36. //.parse
  37.  
  38. void ObjVec::operator+=(const ObjVec& V)
  39.   {ByteVector::operator+=(*((ByteVector*)&V));}
  40.  
  41. //.parse
  42.  
  43. void* ObjVec::Ref(long Index)
  44.   {
  45.     ByteVector::Ref(((Index+1)*BlockSize)-1);
  46.     return PtrInc(P,Index*BlockSize);
  47.   }
  48.  
  49. //.parse
  50.  
  51. void ObjVec::Insert(const ObjVec& V,long Index)
  52.   { ByteVector::Insert(*((ByteVector*)&V),Index*BlockSize); }
  53.  
  54. //.parse
  55.  
  56. void ObjVec::Insert(void* X,long Index)
  57.   {
  58.     ObjVec V(ObjSize,X);
  59.     ByteVector::Insert(*((ByteVector*)&V),Index*BlockSize);
  60.   }
  61.  
  62. //.parse
  63.  
  64. void ObjVec::Delete(long Index,long Length)
  65.   { ByteVector::Delete(Index*BlockSize,Length*BlockSize); }
  66.  
  67. //.parse
  68.  
  69. void ObjVec::operator=(const ObjVec& V){Assign(*((ByteVector*)&V));}
  70.  
  71. //.parse
  72.  
  73. void ObjVec::CopyTo(void* Dest, long Quan) const
  74.   {
  75.     ByteVector::CopyTo(Dest,Quan*ObjSize);
  76.   }
  77.  
  78. //.parse
  79.  
  80. ObjVec ObjVec::Concat(void* X) const
  81.   {
  82.     ObjVec V(*this);
  83.     memcpy(V.Ref(Size()),X,ObjSize);
  84.     return V;
  85.   }
  86.  
  87. //.parse
  88.  
  89. ObjVec ObjVec::Concat(const ObjVec&V2) const
  90.   {
  91.     ObjVec V3(*this);
  92.     V3+=V2;
  93.     return V3;
  94.   }
  95.  
  96. //.parse
  97.  
  98. void ObjVec::CtorHelper(int ObjectSize)
  99.   {
  100.     ObjSize=ObjectSize;
  101.     BlockSize=ObjectSize;
  102.     CFP=NULL;
  103.   }
  104.  
  105. ObjVec::ObjVec(int ObjectSize):ByteVector()
  106.   {CtorHelper(ObjectSize);}
  107.  
  108. ObjVec::ObjVec(int ObjectSize,void* X):ByteVector(X,ObjectSize)
  109.   {CtorHelper(ObjectSize);}
  110.  
  111. ObjVec::ObjVec(int ObjectSize,void* P, long Len):ByteVector(P,ObjectSize*Len)
  112.   {CtorHelper(ObjectSize);}
  113.  
  114. ObjVec::ObjVec(const ObjVec& V):ByteVector(*((ByteVector*)&V))
  115.   {CtorHelper(V.ObjSize);}
  116.  
  117. //.parse
  118.  
  119. void ObjVec::Empty(){ByteVector::Empty();}
  120. ObjVec::operator ConstVoidPointerType()const{return P;}
  121. long ObjVec::Capacity()const{return (Alloc/BlockSize);}
  122. long ObjVec::ByteCapacity()const{return Alloc;}
  123. long ObjVec::ReAlloc(long NewCap){return ByteVector::ReAlloc(NewCap*BlockSize);}
  124. long ObjVec::Size()const{return Len/BlockSize;}
  125.  
  126. //.parse
  127.  
  128. long ObjVec::Index(void* SearchObj, long StartIndex) const
  129.   {
  130.     if (StartIndex>=Size()) return(NotFound);
  131.     long I=StartIndex;
  132.     while ((I<Size()) && (memcmp(SearchObj,PtrInc(P,I*BlockSize),ObjSize)!=0)) I++;
  133.     if (I==Size()) return(NotFound);
  134.     else return(I);
  135.   }
  136.  
  137. //.parse
  138.  
  139. ObjVec ObjVec::After(long Index) const
  140.   {
  141.     return At(Index+1,Size()-Index-1);
  142.   }
  143.  
  144. //.parse
  145.  
  146. ObjVec ObjVec::From(long Index) const
  147.   {
  148.     return At(Index,Size()-Index);
  149.   }
  150.  
  151. //.parse
  152.  
  153. void* ObjVec::At(long I) const
  154.   {
  155.     if (I>=Size()) I=Size()-1;
  156.     return PtrInc(P,I*BlockSize);
  157.   }
  158.  
  159. //.parse
  160.  
  161. ObjVec ObjVec::At(long I,long L) const
  162.   {
  163.     long S=Size();
  164.     ObjVec V(ObjSize);
  165.     if (I<S)
  166.       {
  167.         if (I+L>=S) L=S-I;
  168.         *((ByteVector*)&V)=ByteVector::At(I*BlockSize,L*BlockSize);
  169.       }
  170.     return V;
  171.   }
  172.  
  173. //.parse
  174.  
  175. static int DefaultIntCompFunc(const void* A,const void* B)
  176.   {
  177.     int& a=*((int*)A);
  178.     int& b=*((int*)B);
  179.     if (a>b) return 1;
  180.     else if (a<b) return -1;
  181.     else return 0;
  182.   }
  183.  
  184. static int DefaultLongCompFunc(const void* A,const void* B)
  185.   {
  186.     long& a=*((long*)A);
  187.     long& b=*((long*)B);
  188.     if (a>b) return 1;
  189.     else if (a<b) return -1;
  190.     else return 0;
  191.   }
  192.  
  193. CompFuncPtr ObjVec::CurCompFunc() const
  194.   {
  195.     if (CFP==NULL) return ((ObjSize==2)?DefaultIntCompFunc:DefaultLongCompFunc);
  196.     else return CFP;
  197.   }
  198.  
  199. //.parse
  200.  
  201. long ObjVec::BInsert(void* X)
  202.   {
  203.     long ReturnVal=FindGE(X);
  204.     if (ReturnVal==NotFound)
  205.       {
  206.         ReturnVal=Size();
  207.         AppendOneObj(X);
  208.       }
  209.     else
  210.       {
  211.         CompFuncPtr CF=CurCompFunc();
  212.         if ((*CF)(At(ReturnVal),X)!=0) Insert(X,ReturnVal);
  213.       }
  214.     /*
  215.     long ReturnVal;
  216.     CompFuncPtr CF=CurCompFunc();
  217.     if (Size()==0)
  218.       {
  219.         ReturnVal=0;
  220.         AppendOneObj(X);
  221.       }
  222.     else if ((*CF)(Ref(Size()-1),X)<0)
  223.       {
  224.         ReturnVal=Size();
  225.         AppendOneObj(X);
  226.       }
  227.     else
  228.       {
  229.         long CurLow=0;
  230.         long CurHigh=Size()-1;
  231.         while (CurHigh-CurLow>4)
  232.           {
  233.             long Middle=(CurLow+CurHigh)/2;
  234.             if ((*CF)(Ref(Middle),X)>0) CurHigh=Middle;
  235.             else CurLow=Middle;
  236.           }
  237.         Bool Done=False;
  238.         while(!Done)
  239.           {
  240.             if (CurLow==Size())
  241.               {
  242.                 ReturnVal=CurLow;
  243.                 AppendOneObj(X);
  244.                 Done=True;
  245.               }
  246.             else
  247.               {
  248.                 if ((*CF)(Ref(CurLow),X)<0) CurLow++;
  249.                 else
  250.                   {
  251.                     ReturnVal=CurLow;
  252.                     if ((*CF)(Ref(CurLow),X)>0) Insert(X,CurLow);
  253.                     Done=True;
  254.                   }
  255.               }
  256.           }
  257.       }
  258.     */
  259.     return ReturnVal;
  260.   }
  261.  
  262. //.parse
  263.  
  264. long ObjVec::FindE(void* X) const
  265.   {
  266.     long ReturnVal=FindGE(X);
  267.     if (ReturnVal!=NotFound)
  268.       {
  269.         CompFuncPtr CF=CurCompFunc();
  270.         if ((*CF)(At(ReturnVal),X)!=0) ReturnVal=NotFound;
  271.       }
  272.     return ReturnVal;
  273.   }
  274.  
  275. //.parse
  276.  
  277. long ObjVec::FindGE(void* X) const
  278.   {
  279.     long ReturnVal;
  280.     CompFuncPtr CF=CurCompFunc();
  281.     if (Size()==0) ReturnVal=NotFound;
  282.     else if ((*CF)(At(Size()-1),X)<0) ReturnVal=NotFound;
  283.     else
  284.       {
  285.         long CurLow=0;
  286.         long CurHigh=Size()-1;
  287.         Bool Found=False;
  288.         while (CurHigh-CurLow>4)
  289.           {
  290.             long Middle=(CurLow+CurHigh)/2;
  291.             int CompVal=(*CF)(At(Middle),X);
  292.             if (CompVal==0)
  293.               {
  294.                 ReturnVal=Middle;
  295.                 Found=True;
  296.                 CurLow=CurHigh;
  297.               }
  298.             else if (CompVal>0) CurHigh=Middle;
  299.             else CurLow=Middle;
  300.           }
  301.         if (!Found)
  302.           {
  303.             Bool Done=False;
  304.             while(!Done)
  305.               {
  306.                 if (CurLow==Size())
  307.                   {
  308.                     ReturnVal=NotFound;
  309.                     Done=True;
  310.                   }
  311.                 else
  312.                   {
  313.                     if ((*CF)(At(CurLow),X)<0) CurLow++;
  314.                     else
  315.                       {
  316.                         ReturnVal=CurLow;
  317.                         Done=True;
  318.                       }
  319.                   }
  320.               }
  321.           }
  322.       }
  323.     return ReturnVal;
  324.   }
  325.